import plugin from '../../lib/plugins/plugin.js';
import { takeScreenshot } from '../../lib/common/takeScreenshot.js';

export class AutoScreenshot extends plugin {
  constructor() {
    super({
      name: '网页截图',
      dsc: '风云网页截图 - 支持配置文件',
      event: 'message',
      priority: 500,
      rule: [
        { 
          reg: '^#截图设置$', 
          fnc: 'showConfig',
          permission: 'master'  // 只有主人可以查看和修改配置
        },
        { 
          reg: '^#截图设置\\s+(.+)$', 
          fnc: 'updateConfig',
          permission: 'master'  // 只有主人可以修改配置
        },
        { 
          reg: '^#截图重置$', 
          fnc: 'resetConfig',
          permission: 'master'  // 只有主人可以重置配置
        },
        { 
          reg: '^#截图\\s+.*https?://.*', 
          fnc: 'doCustomScreenshot'  // 所有人都可以使用截图功能
        },
        { 
          reg: '.*https?://.*', 
          fnc: 'doAutoScreenshot'  // 所有人都可以使用自动截图
        }
      ]
    });

    // 配置文件路径
    this.configDir = '/root/XRK-Yunzai/plugins/fengyun';
    this.configFile = `${this.configDir}/screenshot_config.json`;

    // 默认配置
    this.defaultConfig = {
      width: 1920,
      height: 1080,
      type: 'jpeg',
      quality: 85,
      fullpage: true,
      waitUntil: 'networkidle2',
      timeout: 30000,
      delay: 1000,
      deviceScaleFactor: 1,
      isMobile: false,
      hasTouch: false,
      omitBackground: false,
      encoding: 'binary'
    };

    // 多链接配置
    this.multiConfig = {
      maxUrls: 5,
      parallel: true,
      timeoutPerUrl: 25000
    };

    // 初始化当前配置为默认值
    this.currentConfig = { ...this.defaultConfig };
    this.currentMultiConfig = { ...this.multiConfig };

    // 异步初始化配置
    this.initConfig();
  }

  // 初始化配置
  async initConfig() {
    try {
      // 确保配置目录存在
      const fs = await import('fs/promises');
      try {
        await fs.access(this.configDir);
      } catch {
        await fs.mkdir(this.configDir, { recursive: true });
        console.log(`[网页截图] 创建配置目录: ${this.configDir}`);
      }

      // 尝试读取配置文件
      try {
        const configData = await fs.readFile(this.configFile, 'utf8');
        const savedConfig = JSON.parse(configData);
        
        // 安全地合并配置
        if (savedConfig.currentConfig) {
          this.currentConfig = { ...this.defaultConfig, ...savedConfig.currentConfig };
        }
        if (savedConfig.currentMultiConfig) {
          this.currentMultiConfig = { ...this.multiConfig, ...savedConfig.currentMultiConfig };
        }
        
        console.log(`[网页截图] 已加载配置文件: ${this.configFile}`);
      } catch (error) {
        // 配置文件不存在或格式错误，使用默认配置
        console.log(`[网页截图] 创建默认配置文件: ${this.configFile}`);
        await this.saveConfig();
      }
    } catch (error) {
      console.error(`[网页截图] 配置初始化失败:`, error);
      // 确保即使出错也有默认配置
      this.currentConfig = { ...this.defaultConfig };
      this.currentMultiConfig = { ...this.multiConfig };
    }
  }

  // 确保配置在方法调用前已初始化
  async ensureConfig() {
    if (!this.currentConfig.width) {
      await this.initConfig();
    }
  }

  // 保存配置到文件
  async saveConfig() {
    try {
      const fs = await import('fs/promises');
      const configData = {
        currentConfig: this.currentConfig,
        currentMultiConfig: this.currentMultiConfig,
        lastUpdate: new Date().toISOString()
      };
      
      await fs.writeFile(this.configFile, JSON.stringify(configData, null, 2), 'utf8');
      return true;
    } catch (error) {
      console.error(`[网页截图] 保存配置失败:`, error);
      return false;
    }
  }

  async showConfig() {
    // 确保配置已初始化
    await this.ensureConfig();

    const fs = await import('fs/promises');
    let fileInfo = '';
    
    try {
      const stats = await fs.stat(this.configFile);
      fileInfo = `\n💾 配置文件: ${this.configFile}\n📅 最后更新: ${new Date(stats.mtime).toLocaleString('zh-CN')}`;
    } catch {
      fileInfo = `\n💾 配置文件: ${this.configFile} (未找到)`;
    }

    const configMsg = `🎛️ 当前截图配置：

📐 尺寸设置：
• 宽度: ${this.currentConfig.width}px
• 高度: ${this.currentConfig.height}px

🎨 质量设置：
• 图片类型: ${this.currentConfig.type}
• 图片质量: ${this.currentConfig.quality}%
• 透明背景: ${this.currentConfig.omitBackground ? '是' : '否'}

⏰ 时间设置：
• 页面等待: ${this.currentConfig.waitUntil}
• 超时时间: ${this.currentConfig.timeout}ms
• 加载延迟: ${this.currentConfig.delay}ms

📱 其他选项：
• 完整页面: ${this.currentConfig.fullpage ? '是' : '否'}
• 移动端模拟: ${this.currentConfig.isMobile ? '是' : '否'}
• 缩放因子: ${this.currentConfig.deviceScaleFactor}

🔗 多链接设置：
• 最大链接数: ${this.currentMultiConfig.maxUrls}
• 并行截图: ${this.currentMultiConfig.parallel ? '是' : '否'}${fileInfo}

💡 修改命令：
• #截图设置 宽度=1366 高度=768
• #截图设置 画质=90 类型=png
• #截图设置 全页=false 延迟=2000
• #截图设置 最大链接=3 并行=false
• #截图重置 (恢复默认设置)

🖼️ 截图命令：
• #截图 [链接] - 自定义截图
• 直接发送链接 - 自动截图（最多${this.currentMultiConfig.maxUrls}个链接）`;

    await this.e.reply(configMsg);
    return true;
  }

  async updateConfig() {
    // 确保配置已初始化
    await this.ensureConfig();

    const raw = this.e.raw_message || this.e.msg;
    const paramsText = raw.replace(/^#截图设置\s+/, '').trim();
    
    if (!paramsText) {
      await this.e.reply('❌ 请输入要修改的配置参数');
      return false;
    }

    try {
      const updatedParams = this.parseConfigParams(paramsText);
      let updateCount = 0;
      let errorMessages = [];

      // 更新主配置
      for (const [key, value] of Object.entries(updatedParams)) {
        if (key in this.currentConfig) {
          this.currentConfig[key] = value;
          updateCount++;
        } else if (key in this.currentMultiConfig) {
          // 处理多链接配置的键名映射
          const multiKey = this.mapMultiConfigKey(key);
          if (multiKey) {
            this.currentMultiConfig[multiKey] = value;
            updateCount++;
          } else {
            errorMessages.push(`未知配置项: ${key}`);
          }
        } else {
          errorMessages.push(`未知配置项: ${key}`);
        }
      }

      // 保存配置到文件
      const saveResult = await this.saveConfig();
      let saveStatus = saveResult ? '✅ 配置已保存到文件' : '⚠️ 配置已更新但保存到文件失败';

      let resultMsg = `✅ 成功更新 ${updateCount} 个配置项\n${saveStatus}`;
      if (errorMessages.length > 0) {
        resultMsg += `\n❌ 错误项:\n${errorMessages.join('\n')}`;
      }

      // 显示更新后的配置摘要
      resultMsg += `\n\n📊 当前主要设置:\n${this.formatCurrentConfig()}`;

      await this.e.reply(resultMsg);
      return true;

    } catch (error) {
      await this.e.reply(`❌ 配置更新失败: ${error.message}`);
      return false;
    }
  }

  async resetConfig() {
    // 确保配置已初始化
    await this.ensureConfig();

    this.currentConfig = { ...this.defaultConfig };
    this.currentMultiConfig = { ...this.multiConfig };
    
    // 保存重置后的配置
    await this.saveConfig();
    
    await this.e.reply('✅ 截图配置已重置为默认值并保存到文件\n' + this.formatCurrentConfig());
    return true;
  }

  async doCustomScreenshot() {
    // 确保配置已初始化
    await this.ensureConfig();

    const raw = this.e.raw_message || this.e.msg;
    
    // 提取链接
    const urlMatch = raw.match(/https?:\/\/[^\s]+/);
    if (!urlMatch) {
      await this.e.reply('❌ 未找到有效的链接');
      return false;
    }
    const url = urlMatch[0];

    await this.e.reply(`风云将为你截取网页截图，请稍候~\n🔗 ${url}`);

    try {
      const imgPath = await takeScreenshot(
        url,
        `custom_${Date.now()}`,
        this.currentConfig
      );

      await this.e.reply([
        segment.image(imgPath),
        `风云网页截图结果来啦~\n🔗 ${url}`
      ]);

      return true;

    } catch (error) {
      await this.e.reply(`❌ 截图失败：${error.message}\n🔗 ${url}`);
      return false;
    }
  }

  async doAutoScreenshot() {
    // 确保配置已初始化
    await this.ensureConfig();

    // 如果是自定义截图命令，跳过自动截图
    if (this.e.msg.startsWith('#截图')) {
      return false;
    }

    const raw = this.e.raw_message || this.e.msg;
    const urls = raw.match(/https?:\/\/[^\s]+/g);
    if (!urls?.length) return false;

    // 限制最大截图数量
    const screenshotUrls = urls.slice(0, this.currentMultiConfig.maxUrls);
    
    if (urls.length > this.currentMultiConfig.maxUrls) {
      await this.e.reply(`风云将为你截取 ${urls.length} 个链接，将截取前 ${this.currentMultiConfig.maxUrls} 个`);
    } else {
      await this.e.reply(`风云将为你截取 ${screenshotUrls.length} 个网页截图，请稍后~`);
    }

    const screenshotTasks = screenshotUrls.map(async (url, idx) => {
      try {
        const imgPath = await takeScreenshot(
          url,
          `auto_${Date.now()}_${idx}`,
          this.currentConfig
        );
        return {
          success: true,
          url: url,
          content: segment.image(imgPath)
        };
      } catch (error) {
        return {
          success: false,
          url: url,
          content: segment.text(`❌ 截图失败：${error.message}`)
        };
      }
    });

    let results;
    if (this.currentMultiConfig.parallel) {
      results = await Promise.all(screenshotTasks);
    } else {
      results = [];
      for (let i = 0; i < screenshotTasks.length; i++) {
        results.push(await screenshotTasks[i]);
      }
    }

    // 构建转发消息
    const nodes = [
      { 
        user_id: Bot.uin, 
        nickname: '风云网页截图结果来啦~', 
        message: `风云网页截图结果来啦~\n总计: ${screenshotUrls.length} 个链接\n成功: ${results.filter(r => r.success).length} 个\n失败: ${results.filter(r => !r.success).length} 个` 
      }
    ];

    results.forEach((result, index) => {
      nodes.push({
        user_id: Bot.uin,
        nickname: '风云网页截图结果来啦~',
        message: [
          `🔗 链接${index + 1}: ${result.url}`,
          result.content
        ]
      });
    });

    try {
      const forwardMsg = await Bot.makeForwardMsg(nodes);
      await this.e.reply(forwardMsg);
    } catch (error) {
      // 如果转发消息失败，改为逐条发送
      await this.e.reply('📊 截图完成，开始逐条发送结果...');
      for (const result of results) {
        await this.e.reply([
          `🔗 ${result.url}`,
          result.content
        ]);
      }
    }

    return true;
  }

  // ========== 工具方法 ==========

  parseConfigParams(paramsText) {
    const params = {};
    const pairs = paramsText.split(/\s+/);
    
    for (const pair of pairs) {
      const [key, value] = pair.split('=');
      if (!key || value === undefined) continue;

      const normalizedKey = this.normalizeConfigKey(key.trim());
      const normalizedValue = this.normalizeConfigValue(value.trim());
      
      if (normalizedKey && normalizedValue !== undefined) {
        params[normalizedKey] = normalizedValue;
      }
    }
    
    return params;
  }

  normalizeConfigKey(key) {
    const keyMap = {
      // 主配置映射
      '宽度': 'width',
      '高度': 'height',
      '画质': 'quality',
      '质量': 'quality',
      '类型': 'type',
      '全页': 'fullpage',
      '完整页面': 'fullpage',
      '等待': 'waitUntil',
      '超时': 'timeout',
      '延迟': 'delay',
      '缩放': 'deviceScaleFactor',
      '缩放因子': 'deviceScaleFactor',
      '移动端': 'isMobile',
      '触摸': 'hasTouch',
      '透明': 'omitBackground',
      '透明背景': 'omitBackground',
      
      // 多链接配置映射
      '最大链接': 'maxUrls',
      '最大链接数': 'maxUrls',
      '并行': 'parallel',
      '并行截图': 'parallel'
    };
    
    return keyMap[key] || key;
  }

  normalizeConfigValue(value) {
    // 布尔值
    if (value === 'true' || value === '是' || value === '开启') return true;
    if (value === 'false' || value === '否' || value === '关闭') return false;
    
    // 数字
    if (/^\d+$/.test(value)) return parseInt(value, 10);
    if (/^\d+\.\d+$/.test(value)) return parseFloat(value);
    
    // 字符串（保持原样）
    return value;
  }

  mapMultiConfigKey(key) {
    const multiKeyMap = {
      'maxUrls': 'maxUrls',
      'parallel': 'parallel'
    };
    return multiKeyMap[key];
  }

  formatCurrentConfig() {
    return `📐 ${this.currentConfig.width}x${this.currentConfig.height} | 🎨 ${this.currentConfig.type}@${this.currentConfig.quality}% | ⏰ ${this.currentConfig.timeout}ms | 🔗 最大${this.currentMultiConfig.maxUrls}链接`;
  }
}